/*
背景：
我们的教材中已经介绍了表达式求值的算法，现在我们将该算法的功能进行扩展，要求可以处理的运算符包括：+、-、*、/、%（整数取余）、^（乘方）、（、）。

要求：
采用算符优先算法，计算的中间结果只保留整数。

输入：
第一行为整数N。表示下面有N个表达式

从第二行起的后面N行为N个由整数构成的表达式

输出：
共N行，每行为相应表达式的计算结果。

如果判断出表达式有错误，则输出：error.

如果在计算过程中出现除数为0的情况，则输出：Divide 0.

特殊情况说明：

在表达式中，如果操作数出现负数（例如-8），则要特别注意。例如：
10加-8表示为：10+-8。
10减-8表示为：10--8。
*/

/*
测试用例1:
输入：
4
2^3
2^0
2^3^2
2^(3-1)^(10-8)
输出：
8↵
1↵
512↵
16↵

测试用例2:
输入：
11
(2+8
2+8)
8/0
8/(8+5-13)
2^(2-5)
10-(80-30(/3*3+4
10-80-30)/3*3+4
(2+8)(3+2)
(2)3(8)
30(/3+3)+4
10(20-8)+2
输出：
error.↵
error.↵
Divide 0.↵
Divide 0.↵
error.↵
error.↵
error.↵
error.↵
error.↵
error.↵
error.↵

测试用例3:
输入：
2
10(10)
14*10-(10)2
输出：
error.↵
error.↵

测试用例4:
输入：
14
18-32
18/4
18%3
10+20*4
10-20/4
(18-3)*3
10*(10)
(10+2)/(8-10)
(2*3)/(5*2)
10-(80-30)/3*3+4
(((2+8)*2-(2+4)/2)*2-8)*2
(((8+2)*(4/2)))
10/0
(10-80*2
输出：
-14↵
4↵
0↵
90↵
5↵
45↵
100↵
-6↵
0↵
-34↵
52↵
20↵
Divide 0.↵
error.↵
*/

#include <iostream>
#include <vector>
#include <queue>
#include <string>
#include <map>
#include <stack>
#include <cmath>
using namespace std;

// 记录运算符优先级
map<string, int> value = {
	{"(", 0},
	{"+", 1},
	{"-", 1},
	{"*", 2},
	{"/", 2},
	{"%", 2},
	{"^", 3},
};

// string类型表达式 变为 vector类型
vector<string> process(string expression)
{
	// 存储处理之后的结果
	vector<string> proc_expression;
	
	// 存储数字
	string num;
	
	// 遍历每一个字符
	for (int i=0;i<expression.size(); i++)
	{
		char c = expression[i];
		// 如果c是负号
		if (c == '-')
		{
			// 负号在表达式首位，表达正负
			if (i == 0)
			{
				num.push_back(c);
			}
			
			// 不在首位，则看前面是否为算术运算符
			else 
			{
				char pre_c = expression[i-1];
				
				// 如果是运算符
				string operators = "+-*/%^";
				if (operators.find(pre_c) != string::npos)
				{
					num.push_back(c);
				}
				
				// 如果不是运算符，则'-'就是普通的减号 -- 存入表达式
				else {
					// 数字存入表达式
					if (num != "")
					{
						proc_expression.push_back(num);
						num = "";
					}
					
					// '-'存入表达式
					string temp(1, c);
					proc_expression.push_back(temp);
				}
			}
		}
		
		// 如果c是数字 -- 存入num
		else if (c >= '0' && c <= '9')
		{
			num.push_back(c);
		}
		
		// 其他情况
		else 
		{
			// 数字存入表达式
			if (num != "")
				{
					proc_expression.push_back(num);
					num = "";
				}
			
			// 存入表达式
			string temp(1, c);
			proc_expression.push_back(temp);
		}
	}
	
	// 数字存入表达式
	if (num != "")
	{
		proc_expression.push_back(num);
		num = "";
	}
	
	return proc_expression;
}

// 打印处理之后的表达式
void output(queue<vector<string>> proc_expressions)
{
	// 打印处理之后的表达式
	while (!proc_expressions.empty())
	{
		// 取出处理之后的表达式
		vector<string> proc_expression = proc_expressions.front();
		proc_expressions.pop();
		
		for (string s:proc_expression)
			{
				cout << s << " ";
			}
		cout << endl;
	}
}

// 单一操作符计算
int one_operator_compute(stack<int> &number_stack, string op)
{
	// 没有两个元素
	if (number_stack.size() < 2)
		return -999;
	
	// 取出两个数字
	int num2 = number_stack.top();
	number_stack.pop();
	int num1 = number_stack.top();
	number_stack.pop();
	
	// 判断运算符
	string operators = "+-*%/^";
	size_t ind = operators.find(op);
	
	// 运算符不合法
	if (ind == string::npos)
		return -999;
	
	switch(ind)
	{
		case 0:
			return num1 + num2;
		case 1:
			return num1 - num2;
		case 2:
			return num1 * num2;
		case 3:
			return num1 % num2;
		case 4:
			if (num2 == 0) return -9999;
			return num1 / num2;
		case 5:
			if (num2 < 0) return -999;
			return pow(num1, num2);
	}
	
	return -999;
}

// 判断状态转移是否正确 -- 用于判断中缀表达式的合法性
bool transfer_state(int &from_s, int to_s)
{
	// 0: 初始状态
	// 1: (
	// 2: )
	// 3: 运算符
	// 4: 数字
	vector<int> v;
	switch (from_s) {
		case 0:
			v = {1, 4};
			break;
		case 1:
			v = {1, 4};
			break;
		case 2:
			v = {2, 3};
			break;
		case 3:
			v = {1, 4};
			break;
		case 4:
			v = {2, 3};
			break;
	}
	
	from_s = to_s;
	auto t = find(v.begin(), v.end(), to_s);
	return t == v.end();
}

// 表达式求值
string compute(vector<string> proc_expression)
{
	// 记录结果
	string result;
	
	// 辅助栈
	stack<int> number_stack;
	stack<string> operator_stack;
	
	// 记录当前状态
	int state = 0;
	
	// 遍历表达式
	for (int i=0; i<proc_expression.size(); i++)
	{
		string s = proc_expression[i];
		
		// 运算符
		string operators = "+-*/%^";
		
		// 如果遇到左括号、^ -- 直接进操作符栈
		if (s == "(")
		{
			operator_stack.push(s);
			
			bool f = transfer_state(state, 1);
			if (f) return "error.";
		}
		else if (s == "^")
		{
			operator_stack.push(s);
			
			bool f = transfer_state(state, 3);
			if (f) return "error.";
		}
		
		// 如果遇到右括号 -- 全部弹出，直到遇到左括号
		else if (s == ")")
		{
			bool OK = false;
			while(!operator_stack.empty())
			{
				// 查看栈顶元素
				string op = operator_stack.top();
				operator_stack.pop();
				
				if (op == "(")
				{
					OK = true;
					break;
				}
				
				int res = one_operator_compute(number_stack, op);
				
				// 运算出错
				if (res == -999) break;
				
				// 除以0
				if (res == -9999) return "Divide 0.";
				
				// 将运算结果重新压入栈
				number_stack.push(res);
				
			}
			
			if (!OK)
				return "error.";
			
			bool f = transfer_state(state, 2);
			if (f) return "error.";
		}
		
		// 如果遇到运算符
		else if (operators.find(s) != string::npos)
		{
			
			// 如果不为空，则依次弹出运算符，直到栈为空，或者其运算优先级更高
			while(!operator_stack.empty())
			{
				// 取出栈顶运算符
				string top = operator_stack.top();
				
				// 如果其运算优先级更高，直接压入栈
				if (value[top] < value[s])
				{
					operator_stack.push(s);
					break;
				}
				else 
				{
					// 弹出
					operator_stack.pop();
					
					// 运算
					int res = one_operator_compute(number_stack, top);
					
					// 运算出错
					if (res == -999) return "error.";
					
					// 除以0
					if (res == -9999) return "Divide 0.";
					
					// 将运算结果重新压入栈
					number_stack.push(res);
				}
			}
			
			// 如果运算符栈为空，则直接压入
			if (operator_stack.empty())
				operator_stack.push(s);
			
			bool f = transfer_state(state, 3);
			if (f) return "error.";
		}
		
		// 如果遇到数字
		else 
		{
			int num = stoi(s);
			number_stack.push(num);
			
			bool f = transfer_state(state, 4);
			if (f) return "error.";
		}
		
	}
	
	// 将运算符栈内的运算符全部弹出
	while(!operator_stack.empty())
		{
			string op = operator_stack.top();
			operator_stack.pop();
			
			int res = one_operator_compute(number_stack, op);
			
			// 运算出错
			if (res == -999) return "error.";
			
			// 除以0
			if (res == -9999) return "Divide 0.";
			
			// 将运算结果重新压入栈
			number_stack.push(res);
		}
	
	// 取出结果
	if (number_stack.size() != 1 || operator_stack.size() != 0)
		return "error.";
//	cout << operator_stack.size() << endl;
//	cout << number_stack.size() << endl;
	return to_string(number_stack.top());
}

int main()
{
	/* 读取用户输入 */
	// 表达式个数
	int N;
	cin >> N;
	
	// 存储表达式
	queue<string> expressions;
	
	// 依次输入表达式
	for (int i=0; i<N; i++)
	{
		string expression;
		cin >> expression;
		expressions.push(expression);
	}
	
	/* string类型的表达式变成vector类型 */
	queue<vector<string>> proc_expressions;
	while (!expressions.empty())
	{
		// 获取原始的string类型表达式
		string expression = expressions.front();
		expressions.pop();
		
		// 处理成vector类型的表达式
		vector<string> proc_expression;
		proc_expression = process(expression);
		
		// 保存
		proc_expressions.push(proc_expression);
	}
	
	// 打印处理之后的表达式
	// output(proc_expressions);
	
	
	/* 中缀表达式的合法性检验 */
	// 这个部分有待完善.......
	
	
	/* 表达式求值 -- 本质是后缀表达式求值 */
	while (!proc_expressions.empty())
	{
		// 取出处理之后的表达式
		vector<string> proc_expression = proc_expressions.front();
		proc_expressions.pop();
		
		// 计算出结果
		string result = compute(proc_expression);
		
		// 打印
		cout << result << endl;
	}
	
}
